1
2
Neste
I de enkleste termer, gir git pull en git hentet etterfulgt av en git flette.
Du kan når som helst gjøre en git-henting for å oppdatere fjernsporingsgrenene dine under ref / fjernkontroller / /.
Denne operasjonen endrer aldri noen av dine egne lokale filialer under ref / heads, og er trygt å gjøre uten å endre arbeidskopien. Jeg har til og med hørt om folk som kjører git henting med jevne mellomrom i en cron-jobb i bakgrunnen (selv om jeg ikke vil anbefale å gjøre dette).
En git pull er hva du ville gjort for å holde en lokal filial oppdatert med den eksterne versjonen, samtidig som du oppdaterer de andre eksterne sporingsgrenene.
Fra Git-dokumentasjonen for git pull:
I standardmodus er git pull forkortelse for git-henting etterfulgt av git merge FETCH_HEAD.
|
Når du bruker pull, prøver Git å gjøre arbeidet ditt automatisk for deg. Det er kontekstsensitivt, så Git vil slå sammen eventuelle trukket forpliktelser i grenen du jobber i. Pull fusjonerer automatisk forpliktelsene uten å la deg gjennomgå dem først. Hvis du ikke håndterer filialene dine nøye, kan du komme til hyppige konflikter.
Når du henter, samler Git alle forpliktelser fra målgrenen som ikke finnes i din nåværende filial, og lagrer dem i ditt lokale depot. Det fusjonerer dem imidlertid ikke med din nåværende gren. Dette er spesielt nyttig hvis du trenger å holde depotet oppdatert, men jobber med noe som kan gå i stykker hvis du oppdaterer filene dine.
For å integrere forpliktelsene i hovedgrenen din, bruker du flette.
|
Det er viktig å kontrastere gits designfilosofi med filosofien til et mer tradisjonelt kildekontrollverktøy som SVN.
Subversion ble designet og bygget med en klient / servermodell. Det er et enkelt lager som er serveren, og flere klienter kan hente kode fra serveren, jobbe med den og deretter overføre den til serveren. Antagelsen er at klienten alltid kan kontakte serveren når den trenger å utføre en operasjon.
Git ble designet for å støtte en mer distribuert modell uten behov for et sentralt depot (selv om du absolutt kan bruke en hvis du vil). Også git ble designet slik at klienten og "serveren" ikke trenger å være online samtidig. Git ble designet slik at folk på en upålitelig lenke kunne bytte kode via e-post, til og med. Det er mulig å jobbe helt frakoblet og brenne en CD for å utveksle kode via git.
For å støtte denne modellen opprettholder git et lokalt depot med koden din og også et ekstra lokalt depot som speiler tilstanden til det eksterne depotet. Ved å beholde en kopi av det eksterne arkivet lokalt, kan git finne ut hvilke endringer som trengs, selv når det ikke er mulig å få tilgang til det eksterne arkivet. Senere når du trenger å sende endringene til noen andre, kan git overføre dem som et sett med endringer fra et tidspunkt som er kjent til det eksterne depotet.
git fetch er kommandoen som sier "oppdater min lokale kopi av det eksterne depotet."
git pull sier "bringe endringene i det eksterne depotet dit jeg oppbevarer min egen kode."
Normalt gjør git pull dette ved å gjøre en git-henting for å bringe den lokale kopien av det eksterne arkivet oppdatert, og deretter slå sammen endringene i ditt eget kodelager og muligens din arbeidskopi.
Ta bort er å huske at det ofte er minst tre eksemplarer av et prosjekt på arbeidsstasjonen din. En kopi er ditt eget depot med din egen forpliktelseshistorikk. Den andre kopien er arbeidskopien din der du redigerer og bygger. Den tredje kopien er din lokale "hurtigbufrede" kopi av et eksternt lager.
|
Her er Oliver Steeles bilde av hvordan alt passer sammen:
Hvis det er tilstrekkelig interesse, antar jeg at jeg kan oppdatere bildet for å legge til git-klon og git-fusjon ...
|
En brukstilfelle av git-henting er at følgende vil fortelle deg eventuelle endringer i den eksterne grenen siden forrige trekk ... slik at du kan sjekke før du gjør en faktisk trekking, noe som kan endre filer i din nåværende gren og arbeidskopi.
git-henting
git diff ... opprinnelse
Se: https://git-scm.com/docs/git-diff angående dobbel- og tredobbelt-syntaks i diff-kommandoen
|
Det kostet meg litt å forstå hva som var forskjellen, men dette er en enkel forklaring. mester i din lokale vert er en gren.
Når du kloner et depot, henter du hele depotet til din lokale vert. Dette betyr at du på det tidspunktet har en opprinnelses / masterpeker til HEAD og master som peker på samme HEAD.
når du begynner å jobbe og forplikter deg viderefører du hovedpekeren til HEAD + dine forpliktelser. Men opprinnelsen / hovedpekeren peker fortsatt på hva det var da du klonet.
Så forskjellen vil være:
Hvis du gjør en git-henting, vil den bare hente alle endringene i det eksterne arkivet (GitHub) og flytte opprinnelses- / hovedpekeren til HEAD. I mellomtiden vil din lokale avdelingsmester fortsette å peke på hvor den har.
Hvis du gjør en git pull, vil det i utgangspunktet hente (som forklart tidligere) og slå sammen eventuelle nye endringer i dinmastergren og flytt pekeren til HEAD.
|
Noen ganger hjelper en visuell fremstilling.
|
Kort
git fetch ligner på pull men smelter ikke sammen. dvs. det henter fjernoppdateringer (ref og objekter), men din lokale forblir den samme (dvs. opprinnelse / master blir oppdatert, men master forblir den samme).
git pull trekker ned fra en fjernkontroll og smelter umiddelbart.
Mer
git klon kloner en repo.
git rebase lagrer ting fra din nåværende gren som ikke er i oppstrømsgrenen til et midlertidig område. Filialen din er nå den samme som før du startet endringene. Så, git pull -rebase vil trekke ned endringene på fjernkontrollen, spole den lokale grenen tilbake, spille av endringene dine på toppen av din nåværende gren en etter en til du er oppdatert.
Også git branch -a vil vise deg nøyaktig hva som skjer med alle filialene dine - lokale og eksterne.
Dette blogginnlegget var nyttig:
Forskjellen mellom git pull, git fetch og git clone (og git rebase) - Mike Pearce
og dekker git pull, git fetch, git clone og git rebase.
====
OPPDATER
Jeg tenkte å oppdatere dette for å vise hvordan du faktisk ville brukt dette i praksis.
Oppdater din lokale repo fra fjernkontrollen (men ikke flett sammen):
git-henting
Etter å ha lastet ned oppdateringene, la oss se forskjellene:
git diff master origin / master
Hvis du er fornøyd med disse oppdateringene, kan du slå sammen:
git pull
Merknader:
På trinn 2: For mer informasjon om forskjeller mellom lokale og fjernkontroller, se: Hvordan sammenligne en lokal git-gren med den eksterne grenen?
På trinn 3: Det er sannsynligvis mer nøyaktig (f.eks. I en repo som skiftes raskt) å lage en git rebase-opprinnelse her. Se @Justin Ohms kommentar i et annet svar.
Se også: http://longair.net/blog/2009/04/16/git-fetch-and-merge/
|
git-pull - Hent fra og slå sammen med et annet depot eller en lokal filial
SYNOPSIS
git pull ...
BESKRIVELSE
Kjører git-fetch med de gitte parametrene, og kaller git-merge for å slå sammen
hentet hode (r) inn i den nåværende grenen. Med --rebase, kalles git-rebase
i stedet for git-merge.
Merk at du kan bruke. (nåværende katalog) som å trekke
fra det lokale depotet - dette er nyttig når du slår sammen lokale filialer
inn i dagens gren.
Vær også oppmerksom på at alternativene er ment for git-pull selv og underliggende git-merge
må gis før alternativene som er ment for git-henting.
Du ville trekke hvis du vil ha historiene slått sammen, du vil hente hvis du bare vil ha codez, ettersom noen har merket noen artikler her.
|
Du kan hente fra et eksternt lager, se forskjellene og deretter trekke eller slå sammen.
Dette er et eksempel på et eksternt lager som heter opprinnelse og en gren som kalles master som sporer den eksterne grenens opprinnelse / master:
git checkout master
git-henting
git diff opprinnelse / master
git rebase origin master
|
Det korte og enkle svaret er at git pull er ganske enkelt git-henting etterfulgt av git flette.
Det er veldig viktig å merke seg at git pull automatisk smelter sammen om du liker det eller ikke. Dette kan selvfølgelig føre til sammenslåing av konflikter. La oss si at fjernkontrollen din er opprinnelse og grenen din er mester. Hvis du skiller diff origin / master før du trekker, bør du ha en ide om potensielle sammenslåingskonflikter og kan forberede din lokale filial deretter.
I tillegg til å trekke og skyve, involverer noen arbeidsflyter git rebase, som denne, som jeg omskriver fra den koblede artikkelen:
git pull origin master
git kassa foo-gren
git rebase master
git push opprinnelse foo-gren
Hvis du befinner deg i en slik situasjon, kan du bli fristet til å dra - avstand. Med mindre du virkelig, virkelig vet hva du gjør, vil jeg fraråde det. Denne advarselen kommer fra mannssiden for git-pull, versjon 2.3.5:
Dette er en potensielt farlig modus. Det omskrives
historie, som ikke lover godt når du publiserte historien
allerede. Ikke bruk dette alternativet med mindre du har lest git-rebase (1)
nøye.
|
OK, her er litt informasjon om git pull og git-henting, slik at du kan forstå de faktiske forskjellene ... med få enkle ord får henting de nyeste dataene, men ikke koden endres og ikke kommer til å rote med din nåværende lokale avdelingskode , men trekk for å få kodeendringene og slå den sammen din lokale filial, les videre for å få mer informasjon om hver:
git-henting
Den vil laste ned alle ref og objekter og eventuelle nye grener til ditt lokale arkiv ...
Hent grener og / eller koder (samlet "refs") fra en eller flere
andre arkiver, sammen med gjenstandene som er nødvendige for å fullføre dem
historier. Eksterne sporingsgrener oppdateres (se beskrivelsen
nedenfor for måter å kontrollere denne oppførselen på).
Som standard er alle tagger som peker inn i historiene som hentes
også hentet; effekten er å hente koder som peker på grener som
du er interessert i. Denne standardadferden kan endres ved å bruke
alternativene --tags eller --no-tags eller ved å konfigurere
ekstern..tagOpt. Ved å bruke en refspec som eksplisitt henter koder,
du kan hente koder som ikke peker inn i grener du er interessert i
i også.
git fetch kan hente fraenten et enkelt navngitt depot eller URL, eller
fra flere arkiver samtidig hvis det er gitt og det er et
fjernkontroller. oppføring i konfigurasjonsfilen. (Se git-config1).
Når ingen fjernkontroll er spesifisert, vil opprinnelig fjernkontroll være som standard
brukt, med mindre det er en oppstrømsgren konfigurert for gjeldende
gren.
Navnene på refs som hentes, sammen med objektnavnene
de peker på, er skrevet til .git / FETCH_HEAD. Denne informasjonen kan være
brukes av skript eller andre git-kommandoer, for eksempel git-pull.
git pull
Det vil bruke endringene fra fjernkontroll til nåværende filial i lokale ...
Inkluderer endringer fra et eksternt lager i den nåværende grenen.
I standardmodus er git pull forkortelse for git-henting etterfulgt av
git flette FETCH_HEAD.
Mer presist, git pull kjører git fetch med de gitte parametrene og
kaller git merge for å slå sammen de hentede grenhodene til strømmen
gren. Med --rebase kjører den git rebase i stedet for git merge.
skal være navnet på et eksternt lager som det sendes til
git-fetch1. kan gi navn til en vilkårlig ekstern ref (for eksempel
navnet på en tag) eller til og med en samling refs med tilhørende
ekstern sporing av grener (f.eks. refs / heads /: refs / remotes / origin /),
men vanligvis er det navnet på en gren i det eksterne arkivet.
Standardverdier for og leses fra
"ekstern" og "slå sammen" konfigurasjon for den nåværende grenen som angitt av
git-branch - spor.
Jeg lager også det visuelle nedenfor for å vise deg hvordan git-henting og git trekker seg sammen ...
|
Denne interaktive grafiske fremstillingen er veldig nyttig for å understreke git: http://ndpsoftware.com/git-cheatsheet.html
git henter bare "laster ned" endringene fra fjernkontrollen til ditt lokale depot. git pull laster ned endringene og slår dem sammen i din nåværende filial. "I standardmodus er git pull forkortelse for git-henting etterfulgt av git merge FETCH_HEAD."
|
Bonus:
Når jeg snakker om pull & fetch i svarene ovenfor, vil jeg dele et interessant triks,
git pull - avstand
Denne kommandoen over er den mest nyttige kommandoen i mitt liv som sparte mye tid.
Før du skyver den nye forpliktelsen til serveren, kan du prøve denne kommandoen, og den vil automatisk synkronisere de siste serverendringene (med en henting + fletting) og plassere forpliktelsen øverst i git-loggen. Du trenger ikke å bekymre deg for manuell trekking / sammenslåing.
Finn detaljer på: http://gitolite.com/git-pull--rebase
|
Jeg liker å ha en visuell fremstilling av situasjonen for å forstå disse tingene. Kanskje andre utviklere vil se det også, så her er mitt tillegg. Jeg er ikke helt sikker på at alt er riktig, så vær så snill å kommentere hvis du finner noen feil.
LOKALT SYSTEM
. ===================================================== ===
==================. ====================================================
FJERNRAPPORTER. FJERNRAPPORTER LOKAL REPOSITORI ARBEIDSKOPI
(OPPRINNELSE). (CACHED)
for eksempel, . speil av
en github repo. . ekstern repo
Kan også være .
flere repoer.
.
.
FETCH * ------------------> *
Den lokale hurtigbufferen til fjernkontrollen er oppdatert med opprinnelsen (eller flere
eksterne kilder, det er gits distribuerte natur)
.
TREK * -------------------------------------------------------- --------> *
endringene slås sammen direkte i din lokale kopi. når konflikter oppstår,
du blir bedt om avgjørelser.
.
FORPLIKT. * <--------------- *
Når du kommer fra for eksempel undergravning, kan du tro at en forpliktelse
vil oppdatere opprinnelsen. I git blir en forpliktelse bare gjort mot din lokale repo.
.
PUSH * <--------------------------------------- *
Synkroniserer endringene dine tilbake til opprinnelsen.
Noen store fordeler ved å ha et hentet speil på fjernkontrollen er:
Ytelse (bla gjennom alle forpliktelser og meldinger uten å prøve å presse den gjennom nettverket)
Tilbakemelding om tilstanden til din lokale repo (for eksempel bruker jeg Atlassian's SourceTree, som vil gi meg en pære som indikerer om jeg forplikter meg foran eller bak i forhold til opprinnelsen. Denne informasjonen kan oppdateres med GIT FETCH).
|
Jeg har slitt med dette også. Faktisk kom jeg hit med et google-søk på nøyaktig det samme spørsmålet. Å lese alle disse svarene malte til slutt et bilde i hodet på meg, og jeg bestemte meg for å prøve å få dette ned med å se på tilstanden til de to arkivene og en sandkasse og handlinger som ble utført over tid mens jeg så på versjonen av dem. Så her er hva jeg kom på. Rett meg hvis jeg har rotet meg noe sted.
De tre repoer med en henting:
--------------------- ----------------------- ------ -----------------
- Remote Repo - - Remote Repo - - Remote Repo -
- - - blir presset - - -
- @ R01 - - @ R02 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------------------------------
- Lokal repo - - Lokal repo - - Lokal repo -
- trekke - - - - hente -
- @ R01 - - @ R01 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Lokal sandkasse - - Lokal sandkasse - - Lokal sandkasse -
- Kasse - - nytt arbeid utført - - -
- @ R01 - - @ R01 + - - @ R01 + -
--------------------- ----------------------- ------ -----------------
De tre repoer med et trekk
--------------------- ----------------------- ------ -----------------
- Remote Repo - - Remote Repo - - Remote Repo -
- - - blir presset - - -
- @ R01 - - @ R02 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Lokal repo - - Lokal repo - - Lokal repo -
- trekke - - - - trekke -
- @ R01 - - @ R01 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Lokal sandkasse - - Lokal sandkasse - - Lokal sandkasse -
- Kasse - - nytt arbeid utført - - slått sammen med R02 -
- @ R01 - - @ R01 + - - @ R02 + -
--------------------- ----------------------- ------ -----------------
Dette hjalp meg til å forstå hvorfor en henting er ganske viktig.
|
Forskjellen mellom GIT Fetch og GIT Pull kan forklares med følgende scenario:
(Med tanke på at bilder snakker høyere enn ord !, har jeg gitt bilderepresentasjon)
La oss ta et eksempel på at du jobber med et prosjekt med teammedlemmene dine. Så det vil være en hovedgren av prosjektet, og alle bidragsyterne må forkaste den til sitt eget lokale arkiv og deretter jobbe med denne lokale grenen for å modifisere / legge til moduler og deretter skyve tilbake til hovedgrenen.
Så,
Opprinnelig tilstand til de to grenene når du forkaster hovedprosjektet på ditt lokale depot vil være slik- (A, B og C er moduler som allerede er fullført av prosjektet)
Nå har du begynt å jobbe med den nye modulen (antar D), og når du har fullført D-modulen, vil du skyve den til hovedgrenen, men i mellomtiden er det som skjer at en av lagkameratene har utviklet ny modul E, F og modifisert C.
Så det som har skjedd, er at det lokale depotet ditt mangler bak den opprinnelige fremdriften i prosjektet, og dermed å skyve endringene dine til hovedgrenen kan føre til konflikt og kan føre til at modul D fungerer feil.
For å unngå slike problemer og å jobbe parallelt med den opprinnelige fremdriften i prosjektet, er det to måter:
1. Git Fetch- Dette vil laste ned alle endringene som er gjort i opprinnelses- / hovedfilialprosjektet som ikke er til stede i din lokale filial. Og vil vente på Git Merge-kommandoen for å bruke endringene som er hentet i depotet eller grenen din.
Så nå kan du nøye overvåke filene før du slår dem sammen med depotet ditt. Og du kan også endre D om nødvendig på grunn av Modified C.
2. Git Pull- Dette vil oppdatere din lokale filial med opprinnelsen / hovedgrenen, dvs. faktisk hva den gjør er en kombinasjon av Git Fetch og Git fusjonere etter hverandre.
Men dette kan føre til at det oppstår konflikter, så det anbefales å bruke Git Pull med en ren kopi.
|
Vi sier ganske enkelt:
git pull == git fetch + git flette
Hvis du kjører git pull, trenger du ikke å slå sammen dataene til lokale. Hvis du kjører git fetch, betyr det at du må kjøre git merge for å få den nyeste koden til din lokale maskin. Ellers vil den lokale maskinkoden ikke endres uten fletting.
Så i Git Gui, når du henter, må du slå sammen dataene. Henting i seg selv gjør ikke kodeendringene hos din lokale. Du kan sjekke det når du oppdaterer koden ved å hente
en gang hente og se; koden den endres ikke. Så slår du sammen ... Du vil se den endrede koden.
|
git fetch trekker ned koden fra den eksterne serveren til sporingsgrenene i det lokale depotet ditt. Hvis fjernkontrollen heter opprinnelse (standard), vil disse grenene være innenfor opprinnelse /, for eksempel opprinnelse / master, opprinnelse / mybranch-123 osv. Dette er ikke dine nåværende filialer, de er lokale kopier av disse grenene fra serveren .
git pull gjør en git-henting, men slår også sammen koden fra sporingsgrenen til din nåværendelokal versjon av den grenen. Hvis du ikke er klar for endringene ennå, er det bare å hente først.
|
git fetch vil hente eksterne grener slik at du kan git diff eller git flette dem med den nåværende grenen. git pull vil kjøre henting på fjernkontrollen sporet av den nåværende grenen og deretter slå sammen resultatet. Du kan bruke git fetch for å se om det er oppdateringer til den eksterne grenen uten å måtte slå dem sammen med den lokale grenen.
|
Git Fetch
Du laster ned endringer i din lokale filial fra opprinnelse til henting. Fetch ber den eksterne repoen om alle forpliktelser som andre har gjort, men du har ikke på din lokale repo. Fetch laster ned disse forpliktelsene og legger dem til det lokale depotet.
Git Merge
Du kan bruke endringer som er lastet ned gjennom henting ved hjelp av flettkommandoen. Merge tar forpliktelsene hentet fra henting og prøver å legge dem til din lokale filial. Sammenslåingen vil holde forpliktelseshistorikken til dine lokale endringer, slik at når du deler din filial med push, vil Git vite hvordan andre kan slå sammen endringene dine.
Git Pull
Hent og slå sammen ofte nok til at en kommando som kombinerer de to, trekk, ble opprettet. Pull gjør en henting og deretter en sammenslåing for å legge til de nedlastede forpliktelsene i din lokale filial.
|
Enkelt sagt, hvis du var i ferd med å hoppe på et fly uten internettforbindelse ... før du dro, kunne du bare gjøre git-henting opprinnelse . Det vil hente alle endringene på datamaskinen din, men holde den atskilt fra ditt lokale utviklings- / arbeidsområde.
På flyet kan du gjøre endringer i det lokale arbeidsområdet ditt og deretter slå det sammen med det du har hentet og løse potensielle sammenslåingskonflikter alt uten tilkobling til Internett. Og med mindre noen hadde gjort nye endringer i det eksterne depotet, ville du gjøre git push origin og ta kaffen din når du ankommer destinasjonen.
Fra denne fantastiske Atlassian-opplæringen:
Kommandoen git fetch laster ned forpliktelser, filer og referanser fra a
eksternt depot til ditt lokale depot.
Å hente er det du gjør når du vil se hva alle andre har
har jobbet med. Det ligner på SVN-oppdatering, fordi det lar deg se
hvordan den sentrale historien har utviklet seg, men den tvinger deg ikke til det
faktisk slå sammen endringene i depotet ditt. Git isolater
hentet innhold som fra eksisterende lokalt innhold, har det absolutt
ingen effekt på ditt lokale utviklingsarbeid. Hentet innhold må eksplisitt sjekkes ut ved hjelp av kommandoen git checkout. Dette gjør
å hente en trygg måte å gjennomgå forpliktelser før du integrerer dem med
ditt lokale depot.
Når du laster ned innhold fra et eksternt lager, er kommandoer for git pull og git-henting tilgjengelig for å utføre oppgaven. Du kan vurdere
git hent den 'sikre' versjonen av de to kommandoene. Den lastes ned
det eksterne innholdet, men ikke oppdater det lokale lagerets arbeidstilstand,
la ditt nåværende arbeid være intakt. git pull er jo mer aggressivt
alternativt, vil det laste ned eksternt innhold for den aktive lokale
gren og utfør straks git fusjon for å opprette en fusjonsforpliktelse
for det nye eksterne innholdet. Hvis du har pågående endringer i gang
dette vil føre til konflikter og avspark sammenslåing av konfliktløsning
strømme.
Med git pull:
Du får ingen isolasjon.
Det trenger ikke å eksplisitt sjekkes ut. Fordi det implisitt smelter en git.
Sammenslåingstrinnet vil påvirke din lokale utvikling og kan forårsake konflikter
Det er i utgangspunktet IKKE trygt. Det er aggressivt.
I motsetning til git-henting der det bare påvirker .git / refs / fjernkontrollene dine, vil git pull påvirke både .git / refs / fjernkontrollene og .git / refs / heads /
Hmmm ... så hvis jeg ikke oppdaterer arbeidskopien med git-henting, hvor gjør jeg endringer? Hvor lagrer Git de nye forpliktelsene?
Flott spørsmål. Det setter det et sted isolert fra arbeidskopien. Men igjen hvor? La oss finne det ut.
I prosjektkatalogen din (dvs. hvor du gjør git-kommandoene dine) gjør:
ls. Dette viser filene og katalogene. Ikke noe kult, vet jeg.
Gjør nå ls -a. Dette vil vise prikkfiler, dvs. filer som begynner med. Du vil da kunne se en katalog som heter: .git.
Gjør cd .git. Dette vil åpenbart endre katalogen din.
Nå kommer den morsomme delen; gjør ls. Du vil se en liste over kataloger. Vi leter etter ref. Gjør cd-ref.
Det er interessant å se hva som er i alle kataloger, men la oss fokusere på to av dem. hoder og fjernkontroller. Bruk cd for å sjekke inni dem også.
Enhver git-henting du gjør, vil oppdatere elementer i /.git/refs/remotes-katalogen. Den oppdaterer ikke noe i /.git/refs/heads-katalogen.
Ethvert git-trekk gjør først git-hentingen, oppdaterer elementer i /.git/refs/remotes-katalogen, slår seg deretter sammen med den lokale og endrer deretter hodet i /.git/refs/heads-katalogen.
Et veldig godt beslektet svar finner du også i Hvor plasserer 'git fetch' seg selv ?.
Se også etter "Slash notation" fra Git-grenens navnekonvensjonsinnlegg. Det hjelper deg bedre å forstå hvordan Git plasserer ting iforskjellige kataloger.
For å se den faktiske forskjellen
Bare gjør:
git fetch origin master
git checkout master
Hvis den eksterne masteren ble oppdatert, får du en melding som denne:
Filialen din står bak 'origin / master' med to forpliktelser, og kan spoles frem.
(bruk "git pull" for å oppdatere din lokale filial)
Hvis du ikke hentet og bare gjorde git checkout master, ville din lokale git ikke vite at det er lagt til to forpliktelser. Og det vil bare si:
Allerede på 'master'
Filialen din er oppdatert med 'opprinnelse / mester'.
Men det er utdatert og feil. Det er fordi git vil gi deg tilbakemelding utelukkende basert på hva den vet. Det er uvitende om nye forpliktelser at det ikke har trukket seg ennå ...
Er det noen måte å se de nye endringene som er gjort i fjernkontrollen mens du jobber lokalt?
Noen IDEer (f.eks. Xcode) er supersmarte og bruker resultatet av en git-henting og kan kommentere kodelinjene som er endret i den eksterne grenen av din nåværende arbeidsgren. Hvis den linjen har blitt endret av både lokale endringer og ekstern gren, blir den linjen merket med rødt. Dette er ikke en sammenslåingskonflikt. Det er en potensiell sammenslåingskonflikt. Det er en headsup som du kan bruke til å løse den fremtidige sammenslåingskonflikten før du gjør git pull fra den eksterne grenen.
Morsomt tips:
Hvis du hentet en ekstern gren, f.eks. gjorde:
git hente opprinnelsesfunksjon / 123
Da vil dette gå inn i fjernkontrollkatalogen din. Det er fortsatt ikke tilgjengelig for den lokale katalogen. Imidlertid forenkler det kassen din til den eksterne grenen av DWIM (Gjør hva jeg mener):
git checkout-funksjon / 123
du trenger ikke lenger gjøre:
git checkout -b funksjon / 123 opprinnelse / funksjon / 123
For mer om det, les her
|
Den eneste forskjellen mellom git pull og git fetch er at:
git pull trekker fra en ekstern gren og slår den sammen.
git henter bare hentinger fra den eksterne grenen, men den smelter ikke sammen
dvs. git pull = git fetch + git flette ...
|
Git lar kronologisk eldre forpliktelser brukes etter nyere forpliktelser.
På grunn av dette er handlingen med å overføre forpliktelser mellom arkiver delt inn i to trinn:
Kopiering av nye forpliktelser fra ekstern gren til kopi av denne eksterne filialen i lokal repo.
(repo til repo-drift) master @ remote >> remote / origin / master @ local
Integrering av nye forpliktelser til lokal avdeling
(innvendig repo-drift) fjernkontroll / opprinnelse / master @ lokal >> master @ lokal
Det er to måter å gjøre trinn 2. Du kan:
Gaffel lokal gren etter siste felles forfedre, og legg til nye forpliktelser parallelt med forpliktelser som er unike for lokalt depot, avsluttet ved å slå sammen forplikte, lukke gaffelen.
Sett inn nye forpliktelser etter siste felles forfedre og bruk på nytt forpliktelser unikt for lokalt depot.
I git-terminologi er trinn 1 git-henting, trinn 2 er git merge eller git rebase
git pull er git fetch og git flette
|
Git skaffer grenen til den nyeste versjonen fra fjernkontrollen til den lokale ved hjelp av to kommandoer:
git fetch: Git kommer til å få den nyeste versjonen fra ekstern til lokal, men den slås ikke sammen automatisk.
git hente opprinnelsesmester
git log -p master..origin / master
git merge origin / master
Kommandoene ovenfor betyr at du laster ned den siste versjonen av hovedgrenen fra opprinnelse fra hovedgrenen til fjernkontrollen. Og sammenligner deretter den lokale hovedgrenen og opprinnelsesgrenen. Til slutt, slå sammen.
git pull: Git kommer til å få den nyeste versjonen fra fjernkontrollen og slå seg sammen med den lokale.
git pull origin master
Kommandoen ovenfor tilsvarer git-henting og git-fletting. I praksis kan git hente kanskje sikrere fordi vi før fusjonen kan se endringene og bestemme om vi vil slå sammen.
|
Hva er forskjellen mellom git pull og git fetch?
For å forstå dette, må du først forstå at din lokale git vedlikeholder ikke bare ditt lokale lager, men det vedlikeholder også en lokal kopi av det eksterne lagret.
git fetch holder den lokale kopien av det eksterne depotet oppdatert. For eksempel, hvis det eksterne depotet ditt er GitHub - vil du kanskje hente endringer som er gjort i det eksterne depotet til din lokale kopi av det eksterne depotet. Dette vil tillate deg å utføre operasjoner som å sammenligne eller slå sammen.
git pull vil derimot få ned endringene i det eksterne depotet der du oppbevarer din egen kode. Vanligvis vil git pull gjøre en git-henting først for å bringe den lokale kopien av det eksterne depotet oppdatert, og deretter vil det slå sammen endringene i ditt eget kodelager og muligens din arbeidskopi.
|
git pull == (git fetch + git flette)
git fetch endres ikke i lokale grener.
Hvis du allerede har et lokalt lager med en fjernkontroll satt opp for ønsket prosjekt, kan du hente alle grener og koder for den eksisterende fjernkontrollen ved hjelp av git-henting. ... Fetch gjør ingen endringer i lokale grener, så du må slå sammen en ekstern gren med en sammenkoblet lokal gren for å innlemme endringer som nylig er hentet. fra github
|
En enkel grafisk representasjon for nybegynnere,
her,
git pull
vil hente kodefra repository og rebase med din lokale ... i git pull er det mulighet for nye forpliktelser å bli opprettet.
men i ,
git-henting
vil hente kode fra depotet, og vi må basere den på nytt manuelt ved å bruke git rebase
for eksempel: Jeg skal hente fra servermasteren og basere den på nytt i min lokale mester.
1) git pull (rebase vil bli gjort automatisk):
git pull origin master
her opprinnelse er din eksterne repomester er din gren
2) git-henting (må startes på nytt manuelt):
git hente opprinnelsesmester
det vil hente serverendringer fra opprinnelse. og det vil være i ditt lokale til du baserer det på egen hånd. vi må fikse konflikter manuelt ved å sjekke koder.
git rebase opprinnelse / master
dette vil omstarte koden til lokal. før det, sørg for at du er i riktig gren.
|
Prøver å være tydelig og enkel.
Git pull-kommandoen er faktisk en snarvei for git-henting etterfulgt av git merge eller git rebase-kommandoen, avhengig av konfigurasjonen din. Du kan konfigurere Git-depotet slik at git pull er en henting etterfulgt av en rebase.
|
Egentlig vedlikeholder Git en kopi av din egen kode og
det eksterne depotet.
Kommandoen git fetch gjør den lokale kopien din oppdatert ved å hente data fra eksternt arkiv. Grunnen til at vi trenger dette er at noen andre kan ha gjort noen endringer i koden, og du vil holde deg oppdatert.
Kommandoen git pull bringer endringene i det eksterne depotet dit du oppbevarer din egen kode. Normalt gjør git pull dette ved å gjøre en 'git fetch' først for å bringe den lokale kopien av det eksterne arkivet oppdatert, og deretter slår den sammen endringene i ditt eget kodelager og muligens din arbeidskopi.
|
1
2
Neste
Svært aktivt spørsmål. Tjen 10 rykte for å svare på dette spørsmålet. Omdømmekravet hjelper deg med å beskytte dette spørsmålet mot spam og ikke-svar-aktivitet.
Er ikke svaret du leter etter? Bla gjennom andre spørsmål merket git versjonskontroll git-pull git-hent eller still ditt eget spørsmål.